#include<stdio.h>
#include <graphics.h>  
#include <conio.h>
#include <time.h>
#include<math.h>
#include "EasyXPng.h"
#include "Timer.h"
#include <vector>
#include <mmsystem.h>
#pragma comment(lib, "WINMM.LIB")
using namespace std;
#pragma comment(lib,"Winmm.lib")

//设置全局变量
#define WIDTH 1000//界面宽
#define HEIGHT 600//界面高
#define enemy_length 70//敌人图片的长
#define role_length 100//玩家角色图片的长
#define land_height 100 // 地面高度
#define aim_width 25 // 准星图片宽
#define aim_height 26 //准星图片高
#define MaxPlayerBulletNum 100 //玩家子弹最多同时显示100颗
#define PlayerLiveLength 40; //玩家血量图片长度
#define MaxEnemyNum 50  //最多画面上同时存在50位敌人
#define v_bullet 18 // 子弹在其运行方向上的速度
#define r_bullet 3 //玩家子弹半径
#define range 400 // 设置射程
#define enemy_width 41 //敌人图片宽
#define enemy_height 50 //敌人图片高
#define bullet_width 11 //敌人子弹图片宽
#define bullet_height 7 //敌人子弹图片高
#define EnemyLiveHeight 10 //敌人血条高
#define MaxEnemyBulletNum 100 //敌人子弹最多显示100颗
#define BulletsyWidth 16 //玩家剩余子弹图片宽
#define BulletsyHeight 80//玩家剩余子弹图片高
#define ISHOOT_PLAYER 12 //玩家发射子弹的速度限制
#define PlayerLIVE 20 //设置玩家初始生命值
#define time_enemy 100//敌人初始时出现时间间隔
#define ISdifficultup 500 //是否提高难度
#define AnDanJia 18 //一个弹夹中最多的子弹数
#define ISHOOT 200//敌人是否发射子弹

int isdifficult=0;//计时器
int is=0; //难度阶段—敌人出现间隔
int isenemyshoot=0; //难度阶段吧——敌人发射子弹间隔
int ishoot_player=ISHOOT_PLAYER-5;
int player_bullet_num=0; //屏幕上显示的玩家子弹数量
int player_bullet_surplus=100;//玩家剩余子弹
int enemy_bullet_num=0; //敌人子弹数量
int enemy_num=0;//敌人数量
int time_enemy_appear=time_enemy-1;
int score=0; //分数
int Andanjia=AnDanJia; //弹夹中子弹的数量
int isplayershoot=0;

enum playstatus // 枚举玩家角色类型
{
	standleft,standright,runright,runleft,jumpleft,jumpright,shooting,die
};
enum enemystatus// 枚举敌人角色类型
{
	stand,run,shoot,death
};
enum IsshootPlayer
{
	YESshoot,NOTshoot
};

void PlayMusicOnce(TCHAR fileName[35]) // 播放一次音乐函数
{
	TCHAR cmdString1[50];
	_stprintf(cmdString1, _T("open %s alias tmpmusic"), fileName); // 生成命令字符串
	mciSendString(_T("close tmpmusic"), NULL, 0, NULL); // 先把前面一次的音乐关闭
	mciSendString(cmdString1, NULL, 0, NULL); // 打开音乐
	mciSendString(_T("play tmpmusic"), NULL, 0, NULL); // 仅播放一次
}

void updateWithinput();
void updateWithoutinput();
void show();
class Player  // 玩家控制的游戏角色类--左右移动及跳跃_准星射击
{
public:
	IMAGE im_aim;  //准星的图像
	IMAGE im_show;  // 当前时刻要显示的图像
	IMAGE im_role_stand_right; // 向右站立图像
	IMAGE im_role_stand_left; // 向左站立图像
	IMAGE im_role_jump_right; // 向右方向跳跃图像
	IMAGE im_role_jump_left; // 向左方向跳跃图像

	int isinland; // 判断是否在地面上
	
	vector <IMAGE> im_role_runright; // 向右奔跑的图像序列
	vector <IMAGE> im_role_runleft; // 向左奔跑的图像序列

	playstatus roleStatus; // 当前的状态
	IsshootPlayer isshootplyer; //是否射击

	int live;// 生命值
	float x_role,y_role;
	float vx,vy; // 速度
	float gravity; // 重力加速度
	int id;//图片的顺序
	float vy_up;  // 跳跃初始速度
	float aim_x,aim_y; //准星的坐标
	float angle[100];  // 记录下子弹的斜率,且最多发射100颗子弹
	int num_bullet;// 子弹数量
	float start_x,start_y;//子弹初始位置

	void draw()  //绘制人物
	{
		putimagePng2(x_role,y_role,&im_show);
	}

	void draw_mouse() //绘制准星
	{
		IMAGE im_aim;
		loadimage(&im_aim, _T("aim.png"));
		putimagePng2(aim_x, aim_y, &im_aim);
	}

	void update(float mx,float my) // 根据输入的坐标更新准星的位置
	{
		aim_x = mx-aim_width/2.0;
		aim_y = my-aim_height/2.0;
	}

	void initialize() // 初始化
	{
		im_role_runright.clear(); // 先清空掉vector
		im_role_runleft.clear();
		id=0;//
		isinland=1; // 玩家在地面上时为1
		//初始化玩家角色位置
		x_role = WIDTH/2,y_role = HEIGHT-land_height-role_length;
		vy_up=-100;  // 跳跃向上初始速度

		live=PlayerLIVE;//初始生命值为LIVE
		roleStatus=standright; //初始为朝右
		isshootplyer=YESshoot;

		loadimage(&im_role_stand_right,_T("role_runright_0.png"));//导入朝右站立图片
		loadimage(&im_role_stand_left,_T("role_runleft_0.png"));//导入朝左站立图片
		loadimage(&im_role_jump_right,_T("role_runright_0.png"));//导入朝右跳跃图片
		loadimage(&im_role_jump_left,_T("role_runleft_0.png"));//导入朝左跳跃图片
		loadimage(&im_aim,_T("aim.png"));//导入准星图片

		TCHAR filename[130];
		for(int i=0;i<=12;i++)// 把向右奔跑的13张图片对象添加到im_role_runright中
		{
			_stprintf(filename,_T("role_runright_%d.png"),i);
			IMAGE im;
			loadimage(&im,filename);
			im_role_runright.push_back(im);
		}

		for(int i=0;i<=12;i++)//把向左奔跑的13张图片对象添加到im_role_runleft中
		{
			_stprintf(filename,_T("role_runleft_%d.png"),i);
			IMAGE im;
			loadimage(&im,filename);
			im_role_runleft.push_back(im);
		}

		id=0;
		vx=10.0,vy=0;//设置水平移动速度与垂直
		gravity=10;//设置重力加速度

		im_show=im_role_stand_right; // 初始时为向右站立
		draw(); 
	}

	void shoot(float mx,float my)
	{
		if(mx>x_role&&(roleStatus==standleft||roleStatus==runleft||roleStatus==jumpleft)) 
			roleStatus=standright;  // 人物改为朝向右
		else if(mx<x_role&&(roleStatus==standright||roleStatus==runright||roleStatus==jumpright)) // 如果准星在人物的左边且人物朝向右
			roleStatus=standleft;  //任务1改为朝向左
		if(roleStatus==standright||roleStatus==runright||roleStatus==jumpright)//如果人物朝向右
			start_x=x_role+60,start_y=y_role+50;//设置子弹初始位置
		else if(roleStatus==standleft||roleStatus==runleft||roleStatus==jumpleft)//如果人物朝向左
			start_x=x_role+10,start_y=y_role+22;//设置子弹初始位置
		angle[player_bullet_num]=atan((my-start_y)/(mx-start_x));//求每颗子弹的角度
		setfillcolor(BLACK);
		fillcircle(start_x,start_y,r_bullet);//绘制子弹的第一帧画面
		
	}

	void standStill() // 游戏角色默认为向左或向右静止站立
	{
		if (roleStatus == runleft || roleStatus == standleft)
			im_show = im_role_stand_left;
		else if (roleStatus == runright || roleStatus == standright)
			im_show = im_role_stand_right;
	}

	void run_right()//向右奔跑的函数
	{
		x_role=x_role+vx; //角色向右奔跑
		if(x_role>=WIDTH-role_length)// 防止人物走出界面
			x_role=WIDTH-role_length;
		if (roleStatus == jumpleft || roleStatus==jumpright) // 如果是起跳状态
		{
			im_show = im_role_jump_right; // 改变造型为向右起跳造型
		}
		else
		{
			if (roleStatus != runright) // 如果之前角色状态不是向右奔跑
			{
				roleStatus = runright; // 切换为向右奔跑状态
				id = 0; // 动画播放id初始化为0
			}
			else
			{
				id++; // 切换图片
				if(id>=im_role_runright.size()) // 循环
					id=0;
			}
			im_show=im_role_runright[id];
		}
	}

	void run_left()//向左奔跑函数
	{
		x_role=x_role-vx;
		if(x_role<=0) // 防止人物走出界面
			x_role=0;
		if (roleStatus == jumpleft || roleStatus==jumpright) // 如果是起跳状态
		{
			im_show = im_role_jump_left; // 改变造型为向左起跳造型
		}
		else
		{
			if (roleStatus != runleft) // 如果之前角色状态不是向左奔跑
			{
				roleStatus = runleft; // 切换为向左奔跑状态
				id = 0; // 动画播放id初始化为0
			}
			else
			{
				id++; // 切换图片
				if(id>=im_role_runleft.size()) // 循环
					id=0;
			}
			im_show=im_role_runleft[id];   
		}
	}

	void jump_right() //面向右的跳跃
	{
		roleStatus=jumpright;  // 切换人物状态为向右跳跃
		im_show=im_role_jump_right;  //切换图片为向右跳跃
		isinland=0;  // 状态为在空中
		vy=vy_up;  //给予一个向上的速度
	}

	void jump_left() // 面向左的跳跃
	{
		roleStatus=jumpleft;  //切换人物状态为向左跳跃
		im_show=im_role_jump_left;  //切换图片为向左跳跃
		isinland=0;
		vy=vy_up;   //给予一个向上的速度
	}

	void begin_jump()  // 开始跳跃的函数
	{
		cleardevice();//清空之前的画面
		int t=0; //设置时间变量
		if(roleStatus==runright||roleStatus==standright)
			jump_right();
		else if(roleStatus==runleft||roleStatus==standleft)
			jump_left();

		//绘制跳跃过程图像
		for(t=0;t<(-vy_up/gravity)*10;t++)
		{
			vy+=0.1*t*gravity; //速度变化
			y_role-=0.2*(vy*vy-(vy+gravity)*(vy+gravity))/(2.0*gravity);//人物每一段的位移
			if(y_role>HEIGHT-land_height-role_length)//如果超过地面
			{
				y_role=HEIGHT-land_height-role_length;//设置人物在地面上
				if(roleStatus==jumpright)
					roleStatus=runright;
				else if(roleStatus==jumpleft)
					roleStatus=runleft;
				isinland++; //可再次跳跃
				draw();
				break;
			}
			updateWithinput();
			updateWithoutinput();
			show();
			Sleep(30);
			cleardevice();//清空之前的图片
		}
	}
};
Player player; 

class Enemy // 设置敌对单位
{
public:
	IMAGE im_show;  // 当前时刻要显示的图像
	IMAGE im_stand_left; // 向左站立图像
	IMAGE im_stand_right; // 向右站立图像

	vector <IMAGE> im_run; // 向左奔跑的图像序列
	int live;//敌人生命值
	enemystatus enemyStatus; // 当前的状态
	int isshoot; //设置敌人发射子弹条件
	int shoot; //敌人子弹发射

	float x_enemy,y_enemy;
	float vx; // 速度
	int id;//图片的顺序
	float end_x; //敌人最终停止坐标
	int number;//用于生成随机数

	void draw()
	{
		putimagePng2(x_enemy,y_enemy,&im_show);
		setfillcolor(RED);//血条颜色
		setlinecolor(RED);//血条颜色
		fillrectangle(x_enemy,y_enemy-EnemyLiveHeight,x_enemy+enemy_width*live/3.0,y_enemy);//绘制血量
		setlinecolor(BLACK);//血条框为黑色
		rectangle(x_enemy,y_enemy-EnemyLiveHeight,x_enemy+enemy_width,y_enemy);//绘制血条框架
	}

	void initialize() // 初始化
	{
		srand(time(NULL)); //生成随机数种子
		number=rand()%10; //获取0--9的随机数
		if(number==0)
			number=1;//使number不为0
		end_x=number*WIDTH/10; //随机获取敌人停止坐标

		im_run.clear(); // 先清空掉vector
		id=0;
		//初始化敌人角色位置
		x_enemy = WIDTH-enemy_width;
		y_enemy = HEIGHT-land_height-enemy_height;
		live=3; //敌人初始生命为3，即需要3颗子弹完成击杀
		enemyStatus=stand;//初始为
		isshoot=ISHOOT-isenemyshoot*10;//发射条件为ISHOOT个循环一次
		shoot=isshoot-30;//初始为isshoot-30

		loadimage(&im_stand_right,_T("敌人1右.png"));//导入向右站立图片
		loadimage(&im_stand_left,_T("敌人1.png"));//导入向左站立图片

		TCHAR filename2[130];
		for(int i=1;i<=7;i++)// 把向左奔跑的6张图片对象添加到im_run中
		{
			_stprintf(filename2,_T("敌人%d.png"),i);
			IMAGE im;
			loadimage(&im,filename2);
			im_run.push_back(im);
		}
		id=0;
		vx=3;//设置水平移动速度与垂直
		im_show=im_stand_right; // 初始时为向左站立
	}

	void runleft()//向左奔跑函数
	{
		x_enemy-=vx;
		if(x_enemy<=end_x)
		{
			x_enemy=end_x;
		    enemyStatus=stand;
		}
		if (enemyStatus != run&&x_enemy>end_x)
		{
			enemyStatus = run; // 切换为向左奔跑状态
			id = 0; // 动画播放id初始化为0
		}
		else
		{
			id++; // 切换图片
			if(id>=im_run.size()) // 循环
			{
				id=0;
			}
		}
		im_show=im_run[id];   
	}

	void delect()
	{
		if(player.x_role+role_length/2>=x_enemy+enemy_width/2)
		{
			im_show=im_stand_right;
		}
		else if(player.x_role+role_length/2<x_enemy+enemy_width/2)
		{
			im_show=im_stand_left;
		}
	}
};

Enemy enemy[MaxEnemyNum];

class Bullet_player // 设置玩家子弹 
{
public:
	float player_bullet_x,player_bullet_y; //玩家子弹的坐标
	float angle_play;//玩家每颗子弹的发射角度
	float angle_enemy;
	float vx,vy;   //  子弹的水平速度和垂直速度
	float start_x,start_y;

	void draw_player()//显示玩家子弹
	{
		fillcircle(player_bullet_x,player_bullet_x,r_bullet);
	}

	void update() // 更新子弹的位置、速度
	{
		player_bullet_x+= vx;
		player_bullet_y+= vy;
	}
	void draw()
	{
		setfillcolor(YELLOW);
		fillcircle(player_bullet_x,player_bullet_y,r_bullet);
	}
};

class Bullet  // 定义敌人子弹类
{
public:
	IMAGE im_bullet; // 子弹图像
	float x,y; // 子弹坐标
	float vx,vy; // 子弹速度
	float start_x,start_y; //子弹初始坐标
	float end_x,end_y;//子弹目标位置
	float angle;//发射角度

	void draw()// 显示子弹	
	{
		putimagePng(x,y,&im_bullet); 
	}
	void update()
	{
		x-=vx;
		y-=vy;
	}
	void initialize(int n)
	{
		
		start_x=enemy[n].x_enemy-bullet_width;//设置子弹初始坐标
		start_y=enemy[n].y_enemy+2.0/5*enemy_height-bullet_height;//设置子弹初始坐标
		x=enemy[n].x_enemy-bullet_width;
		y=enemy[n].y_enemy+2.0/5*enemy_height-bullet_height;//
		end_x=player.x_role+role_length/2; //目标为玩家
		end_y=player.y_role+role_length/2;//目标为玩家

		if(end_x-start_x!=0)
			angle=atan((end_y-start_y)/(end_x-start_x));

		if(enemy[n].x_enemy<player.x_role)
		{
			loadimage(&im_bullet, _T("bullet2.png"));//插入敌人子弹图片
			vx=-v_bullet*cos(angle);
			vy=-v_bullet*sin(angle);
		}
		else if(enemy[n].x_enemy>player.x_role)
		{
			loadimage(&im_bullet, _T("bullet.png"));//插入敌人子弹图片
			vx=v_bullet*cos(angle);
			vy=v_bullet*sin(angle);
		}
	}
};

class Sence //游戏场景类
{
public:
	IMAGE im_bullet_sy;  //代表剩余子弹的图像
	IMAGE im_danjia; //代表弹夹的图像
	IMAGE im_live;//代表生命值的图像
	IMAGE im_bk; //背景1
	IMAGE im_bk2;//背景2
	IMAGE im_bk3;//背景3
	IMAGE im_bk4;//背景4
	IMAGE im_end;//结束显示图片

	void draw() //绘制场景
	{
		putimagePng(0,0,&im_bk);
		putimagePng(200,200,&im_bk2);
		putimagePng(520,200,&im_bk3);
		putimagePng(850,200,&im_bk4);
	}

	void initialize()
	{
		//导入背景图片
		loadimage(&im_bk,_T("beijing6.png"));
		loadimage(&im_bk2,_T("beijing3.png"));
		loadimage(&im_bk3,_T("beijing4.png"));
		loadimage(&im_bk4,_T("beijing5.png"));
		loadimage(&im_bullet_sy,_T("bullet_sy.png"));//导入剩余子弹图片
		loadimage(&im_danjia,_T("弹夹.png"));//导入弹夹图片
		loadimage(&im_live,_T("player_live.png"));//导入生命值图片
		loadimage(&im_end,_T("end.png"));//导入结束图片
	}

	void player_message() //显示玩家相关信息
	{
		//显示玩家剩余子弹数
		putimagePng(WIDTH/4,0,&im_bullet_sy);
		TCHAR s[40];
		_stprintf(s,_T("%d"),player_bullet_surplus);
		settextstyle(80,0,_T("Time"));
		settextcolor(RGB(50,50,50));
		outtextxy(WIDTH/4+BulletsyWidth,0,s);

		//显示弹夹中剩余的子弹数
		putimagePng(WIDTH/4+150,0,&im_danjia);
		TCHAR s2[40];
		_stprintf(s2,_T("%d"),Andanjia);
		settextstyle(80,0,_T("Time"));
		settextcolor(RGB(50,50,50));
		outtextxy(WIDTH/4+150+48,0,s2);

		//显示玩家剩余生命值
		float x_live=0,y_live=0;//一个生命值图像坐标
		for(int i=1;i<=player.live;i++)
		{
			x_live+=PlayerLiveLength;
			if(i==1)
				x_live=0;
			if(i%5==1&&i!=1)
			{
				x_live=0;
				y_live+=PlayerLiveLength;
			}
			putimagePng(x_live,y_live,&im_live);
		}

		//显示玩家分数
		TCHAR c[] = _T("score："); // 定义字符串数组
		settextstyle(80, 0, _T("Times")); // 设置文字大小、字体
		settextcolor(RGB(50,50,50));  // 设置字体颜色
		outtextxy(WIDTH/2+150,0,c ); // 输出得分文字
		TCHAR s1[40];
		_stprintf(s1,_T("%d"),score);
		settextstyle(80,0,_T("Time"));
		settextcolor(RGB(50,50,50));
		outtextxy(4*WIDTH/5+20,0,s1);
	}

	void playershoot()
	{
		PlayMusicOnce(_T("playershoot.mp3"));
	}

	void chushi()
	{
		IMAGE im_chushi;//
		IMAGE im_chushi2;//
		initgraph(WIDTH,HEIGHT);//新开一个页面
		setbkcolor(WHITE);//设置背景为白色
		cleardevice();
		loadimage(&im_chushi2,_T("chushi2.png"));
		putimagePng(0,0,&im_chushi2);
		Sleep(2000);
		loadimage(&im_chushi,_T("chushi.png"));
		putimagePng(0,0,&im_chushi);
		system("pause");
	}

	void TheEnd()
	{
		putimage(0,0,&im_end);
		TCHAR s[40];
		_stprintf(s,_T("%d"),score);
		settextstyle(80,0,_T("Time"));
		settextcolor(RGB(50,50,50));
		outtextxy(450,HEIGHT-180,s);
	}
};

Sence sence;
Timer timer;  // 用于精确延时
Bullet_player bullet_player[MaxPlayerBulletNum];
Bullet bullet[MaxEnemyBulletNum];

void change_player_bullet(int n) //消失一颗子弹，更新子弹数量及信息
{
	player_bullet_num--;
	for(int i=n;i<player_bullet_num;i++)
	{
		bullet_player[i].angle_play=bullet_player[i+1].angle_play;
		bullet_player[i].start_x=bullet_player[i+1].start_x;
		bullet_player[i].start_y=bullet_player[i+1].start_y;
		bullet_player[i].player_bullet_x=bullet_player[i+1].player_bullet_x;
		bullet_player[i].player_bullet_y=bullet_player[i+1].player_bullet_y;
		bullet_player[i].vx=bullet_player[i+1].vx;
		bullet_player[i].vy=bullet_player[i+1].vy;
	}
}

void change_enemy_bullet(int n)//消失一颗子弹，更新子弹数量及信息
{
	enemy_bullet_num--;
	for(int i=n;i<enemy_bullet_num;i++)
	{
		bullet[i].vx=bullet[i+1].vx;
		bullet[i].vy=bullet[i+1].vy;
		bullet[i].angle=bullet[i+1].angle;
		bullet[i].start_x=bullet[i+1].start_x;
		bullet[i].start_y=bullet[i+1].start_y;
		bullet[i].end_x=bullet[i+1].end_x;
		bullet[i].end_y=bullet[i+1].end_y;
		bullet[i].x=bullet[i+1].x;
		bullet[i].y=bullet[i+1].y;
	}
}

void change_enemy(int n)
{
	enemy_num--;
	for(int i=n;i<enemy_num;i++)
	{   //更新各个数据
		enemy[i].id=enemy[i+1].id;
		enemy[i].x_enemy=enemy[i+1].x_enemy;
		enemy[i].y_enemy=enemy[i+1].y_enemy;
		enemy[i].im_show=enemy[i+1].im_show;
		enemy[i].live=enemy[i+1].live;
		enemy[i].shoot=enemy[i+1].shoot;
		enemy[i].isshoot=enemy[i+1].isshoot;
		enemy[i].end_x=enemy[i+1].end_x;
		enemy[i].enemyStatus=enemy[i+1].enemyStatus;
	}
}

void iskillenemy() //判断玩家子弹是否击中敌人
{
	for(int i=0;i<enemy_num;i++)
	{
		for(int k=0;k<player_bullet_num;k++)
		{
			//当子弹击打到敌人
			if((bullet_player[k].player_bullet_y+r_bullet>=enemy[i].y_enemy)
				&&(bullet_player[k].player_bullet_y+r_bullet<=enemy[i].y_enemy+enemy_height)
				&&(bullet_player[k].player_bullet_x+r_bullet>=enemy[i].x_enemy)
				&&(bullet_player[k].player_bullet_x+r_bullet<=enemy[i].x_enemy+enemy_width))
			{
				enemy[i].live--;
				change_player_bullet(k);
			}
		}
	}
}

void iskillplayer()
{
	for(int i=0;i<enemy_bullet_num;i++)
	{
		//当敌人子弹击中玩家
		if(bullet[i].x+bullet_width/2.0>=player.x_role
			&&bullet[i].x+bullet_width/2.0<=player.x_role+role_length
			&&bullet[i].y+bullet_height/2.0>=player.y_role
			&&bullet[i].y+bullet_height/2.0<=player.y_role+role_length)
		{
			player.live--;
			change_enemy_bullet(i);
		}
	}
}

void start()
{
	mciSendString(_T("open backmusic.mp3 alias bkmusic"),NULL,0,NULL); // 打开背景音乐
	mciSendString(_T("play bkmusic repeat"),NULL,0,NULL);//循环播放
	initgraph(WIDTH,HEIGHT);//新开一个页面
	setbkcolor(WHITE);//设置背景为白色
	setlinecolor(BLACK);
	cleardevice();
	player.initialize();//人物类初始化
	sence.initialize();//各类信息图像初始化
}

void updateWithinput()//与输入有关的更新
{
	player.standStill();
	if(kbhit())  //当按键时
	{
		if(GetAsyncKeyState(VK_RIGHT)||GetAsyncKeyState('D'))
		{
			player.run_right();
		}
		else if(GetAsyncKeyState(VK_LEFT)||GetAsyncKeyState('A'))
		{
			player.run_left();
		}
		if((GetAsyncKeyState(VK_UP)||GetAsyncKeyState('W'))&&(player.isinland!=0))
		{
			player.begin_jump();
		}

		if(GetAsyncKeyState('R')&&Andanjia<AnDanJia&&player_bullet_surplus>0)
		{
			player.isshootplyer=NOTshoot; //切换为不可射击
			PlayMusicOnce(_T("换弹.wav")); //播放一次换弹的音效
			if((AnDanJia-Andanjia)>=player_bullet_surplus) //如果剩余子弹不足以补满弹夹
			{
				Andanjia+=player_bullet_surplus;
				player_bullet_surplus=0;
			}
			else
			{
				player_bullet_surplus=player_bullet_surplus-(AnDanJia-Andanjia);
				Andanjia=AnDanJia;
			}
		}
	}
	MOUSEMSG m;		// 定义鼠标消息
	while (MouseHit())  // 检测当前是否有鼠标消息
	{
		m = GetMouseMsg();
		if(m.uMsg == WM_MOUSEMOVE)  // 到鼠标移动时			
			player.update(m.x,m.y); // 火箭的位置等于鼠标所在的位置
		if(m.mkLButton&&player.isshootplyer==YESshoot)
		{
			ishoot_player++;
			if(((player.roleStatus==runright&&m.x<player.x_role)||(player.roleStatus==runleft&&m.x>player.x_role))
				||ishoot_player<=ISHOOT_PLAYER);
			//如果射击方向与行走方向相反,不运行
			else
			{
				PlayMusicOnce(_T("player_shoot.wav"));
				ishoot_player=0;
				//玩家剩余子弹不为零且弹夹中子弹不为零 屏幕中的子弹未达到上限
				if(player_bullet_num<MaxPlayerBulletNum&&Andanjia>0)
				{
					Andanjia--; //弹夹内子弹数量-1
					player_bullet_num++; //显示的玩家子弹数量加1
					player.shoot(m.x,m.y); //执行函数
					//初始化子弹的信息
					bullet_player[player_bullet_num-1].angle_play=player.angle[player_bullet_num-1];
					bullet_player[player_bullet_num-1].start_x=player.start_x;
					bullet_player[player_bullet_num-1].start_y=player.start_y;
					bullet_player[player_bullet_num-1].player_bullet_x=player.start_x;
					bullet_player[player_bullet_num-1].player_bullet_y=player.start_y;

					if(player.roleStatus==standright||player.roleStatus==runright||player.roleStatus==jumpright)
					{
						bullet_player[player_bullet_num-1].vx=v_bullet*cos(bullet_player[player_bullet_num-1].angle_play);
						bullet_player[player_bullet_num-1].vy=v_bullet*sin(bullet_player[player_bullet_num-1].angle_play);
					}
					else if(player.roleStatus==standleft||player.roleStatus==runleft||player.roleStatus==jumpleft)
					{
						bullet_player[player_bullet_num-1].vx=-v_bullet*cos(bullet_player[player_bullet_num-1].angle_play);
						bullet_player[player_bullet_num-1].vy=-v_bullet*sin(bullet_player[player_bullet_num-1].angle_play);
					}
				}
			}
		}
	}	
}

void updateWithoutinput()//与输入无关的更新
{
	isdifficult++;
	ishoot_player++;
	time_enemy_appear++;
	if(player.isshootplyer==NOTshoot)
	{
		isplayershoot++;
		if(isplayershoot>=100)
		{
			isplayershoot=0;
			player.isshootplyer=YESshoot;
		}
	}
	if(isdifficult>ISdifficultup) //判断是否提高游戏难度
	{
		isdifficult=0;
		if(is<8)
		{//提高一个难度
			isenemyshoot++;
			is++;  
		}
	}
	//判断是否出现敌人
	if(time_enemy_appear>=(time_enemy-is*5)&&enemy_num<MaxEnemyBulletNum)
	{
		enemy_num++;//敌人数量增加
		time_enemy_appear=0;
		enemy[enemy_num-1].initialize();//初始化一个敌人
	}
	iskillenemy();
	for(int i=0;i<enemy_num;i++) // 判断敌人是否死亡
	{
		if(enemy[i].live<=0)
		{
			player_bullet_surplus+=5;//玩家剩余子弹加5
			score++;
			change_enemy(i);
		}
	}
	for(int i=0;i<enemy_num;i++)// 更新敌人位置及子弹发射
	{
		enemy[i].runleft();
		if(enemy[i].enemyStatus==stand)
		{
			enemy[i].delect();
		}
		enemy[i].shoot++;
		if(enemy[i].shoot>=enemy[i].isshoot&&enemy_bullet_num<MaxEnemyBulletNum)//敌人是否满足发射条件
		{
			enemy_bullet_num++;//敌人子弹数+1
			bullet[enemy_bullet_num-1].initialize(i);//初始化一颗敌人子弹
			enemy[i].shoot=0;
		}
		if(enemy[i].shoot>=enemy[i].isshoot)
			enemy[i].shoot=0;//防止数据过大
	}
	float d;
	for(int i=0;i<player_bullet_num;i++)
	{
		d=pow(bullet_player[i].start_x-bullet_player[i].start_x,2)+pow(bullet_player[i].start_y-bullet_player[i].start_y,2);
		d=sqrt(d);
		if(d>=range
			||bullet_player[i].player_bullet_x>WIDTH
			||bullet_player[i].player_bullet_x<0
			||bullet_player[i].player_bullet_y<0
			||bullet_player[i].player_bullet_y>HEIGHT-land_height)
			//判断敌人子弹是否是否跃出界面
		{

			change_player_bullet(i);
		}
	}
	for(int i=0;i<enemy_bullet_num;i++)
	{
		if(bullet[i].x<0||bullet[i].x>WIDTH
			||bullet[i].y>HEIGHT-land_height
			||bullet[i].y<0)
		{
			change_enemy_bullet(i);
		}
	}
	iskillplayer();
	for(int i=0;i<player_bullet_num;i++)//更新玩家子弹
	{
		bullet_player[i].update();
	}
	for(int i=0;i<enemy_bullet_num;i++)
	{
		bullet[i].update();
	}
	player.standStill();
}

void show()
{
	BeginBatchDraw();
	sence.draw();
	sence.player_message();
	player.draw();
	player.draw_mouse();
	for (int i=0;i<player_bullet_num;i++)
		bullet_player[i].draw();  // 显示玩家已有的子弹
	for(int i=0;i<enemy_num;i++)
	{
		enemy[i].draw(); // 显示场上敌人
	}
	for(int i=0;i<enemy_bullet_num;i++)
	{
		bullet[i].draw(); // 显示场上敌人子弹
	}
	if(player.live<=0) //如果角色死亡
	{
		sence.TheEnd();
		system("pause");
	}
	FlushBatchDraw();
	timer.Sleep(30);
}

int main()
{
	sence.chushi();
	start();
	while(1)
	{
		show();
		updateWithoutinput();
		updateWithinput();
		cleardevice();
	}
	_getch();
	return 0;
}